The representation of numbers in data processing systems, particularly non-integer numbers, requires the introduction of a radix point into the notation. For example, data processing systems may employ "fixed point notation" wherein the radix point is placed immediately to the right of the least significant bit or placed immediately to the right of the sign bit before the first information bit.
A further option is often referred to as "floating point notation" in which the numbers are represented by a sign, an exponent, and a mantissa. Such technique is described in many texts, one example being "Computer Architecture", Caxton C. Foster, Van Nostrand Reinhold Co., New York 1976, pages 16 et seq.
Calculations upon the mantissa may be performed by operating on groups of bits (i.e., "bit slices") of the mantissa words involved, the computation for each bit slice producing a "carry" bit to be added to the adjacent bit slice until the calculation is completed for the entire word. For example, overall mantissa words having 32 bits may use eight 4-bit slice logic units in such calculations.
If each bit slice is permitted to produce its "carry" bit only after the operation for such bit slice has occurred and the carry bit is then added to the next bit slice, the overall calculation time is considerably longer than desired. In order to reduce the overall calculation time, techniques for effectively computing the carry bits ahead of time, i.e., so-called "look ahead" carry bit techniques have been devised wherein the various carry bits are computed in parallel and simultaneously with the bit slice computation operations. Such techniques have been used for many years and are well known to those in the art.
After the overall computation has been completed, a "round" bit is then computed and added to the last bit slice as discussed below, the round bit being determined by a plurality of bits, often referred to as "guard" bits, which form a particular coded word which must be suitably decoded to produce the round bit. The round bit is usually calculated following the overall computation and then added to the least significant bit of the unrounded floating point result at the appropriate carry bit location, an operation which can be thought of as an effective multiplexing operation, i.e., the round bit being inserted during the rounding cycle instead of the associated carry bit. For example, when using 32-bit words, the unrounded floating point result comprises 32 bits and is then rounded to a final result having 24 bits. In such case, the unbiased rounding algorithm uses the eight bits of least significance to determine how to round the final 24-bit result. However, the insertion of the round bit to the completed floating point computation result by effective multiplexing techniques adds additional time to all of the calculations required for the mantissa calculation. It is desirable to devise techniques to save this time.
Further, in calculating the exponent portion of a floating point result, if the calculation does not produce a value which falls within a particular exponent value range (i.e., a value having a particular number of bits), an "overflow" or an "underflow" condition occurs. If either such condition occurs, the system must provide an indication thereof so that appropriate sub-routines for handling such conditions can be invoked and the status of the floating point condition must be appropriately communicated to the overall system. In order to save time in the overall operation it is desirable to accelerate the detection and communication of exponent overflow and underflow conditions.
Further, in a multiply or divide operation, conventional algorithms which are used for such operations require that certain operands be extended, i.e., that additional bits be added to the operand words. For example, in a particular multiply algorithm such operands must be extended by two bits, while in a particular divide algorithm such operands must be extended by one bit. Extension techniques which require the use of extra bit slice logic units add to the hardware complexity of the arithmetic units or floating point units. It is desirable to devise less cumbersome extension techniques for such purpose to avoid such hardware complexity.